The present invention relates to information handling systems, and, more particularly, to a system and method for detecting and reordering the loading patterns of application and library files.
After code is written, either for an application program or for a library file (e.g., a dynamically linked library, or DLL), it is compiled into object code. An application program typically consists of one or more separately compiled program modules. A computer program, known as a linker, accepts the separately compiled object code files, and links them together into an executable application program file. As part of the linking step, the linker resolves references between the program modules.
A DLL is a library file which is dynamically loaded when an application program is either loaded or executed, rather than being compiled and linked into the application program""s executable file. This means that the same block of library code can be shared between several application programs, rather than each application program containing copies of the library code it uses. A DLL typically consists of one or more separately compiled library modules. A linker links the object code files of the separately compiled library modules into one DLL file.
Linkers produce executable application and library files with clearly defined object boundaries. In other words, the pages from a particular data object are grouped next to one another, and are not intermixed with pages from another data object or from other types of objects, such as text objects or resource objects. Furthermore, the pages within a given object typically have sequential file offsets. In other words, the first page of the object is page zero, the second page of the object is page one, etc. While this file-offset grouping is convenient for the linker to produce, it may negatively impact application and library load times. As discussed below, the pages within an object are rarely loaded in sequential order.
To execute an application program, an application program executable file and any required library files are loaded by a loader. A loader begins by loading the first page of the application program. The loader next loads any pages within the application program referenced by the first page. The pages within the application program which are referenced by the first page are not necessarily the next sequential pages in the application program executable file. Similarly, as each additional page is loaded, any pages referenced by the loaded page are also loaded. Thus, the pages of the application program are typically loaded in a non-sequential manner. Page reference patterns are rarely sequential within an object, and generally involve random referencing between many objects.
A DLL is loaded on an xe2x80x9cas-neededxe2x80x9d basis by the loader, either as the application program is being loaded or while it is executing. The loader begins by loading the first page of the DLL. The loader next loads any DLL pages referenced by the first page of the DLL. The pages referenced by the first DLL page are not necessarily the next sequential pages of the DLL file, and may even be pages of other DLL files. As each additional page is loaded, any pages referenced by the loaded page are also loaded. Thus, as with the application program, the pages of DLL files are also typically loaded in a non-sequential manner. Within a DLL, as within an application program, page reference patterns are rarely sequential within an object, and generally involve random referencing between many objects.
Loading pages in a non-sequential manner is inefficient. Most file systems perform a function referred to as xe2x80x9cread-ahead.xe2x80x9d When a page is requested from disk (or other storage) in order to be loaded into memory, the file system obtains the requested page, along with one or more pages stored immediately following the requested page. Because the loader rarely loads pages in sequential order, however, these additional pages are usually not the next pages needed. Non-sequential loading does not allow the loader to take advantage of the file system""s read-ahead capabilities.
Consequently, it would be desirable to have a system and method for loading application and library files in an efficient manner. It would also be desirable to take advantage of read-ahead capabilities of a file system in order to reduce application and library load times.
Accordingly, the present invention is directed to a method, system, and computer readable medium for detecting the loading pattern of application and library files, and then reordering the files so that future loads are performed more efficiently. The present invention detects the loading pattern of an application file and library files, and then reorders the pages within the application and library executable files so that future loads are sequential. After being reordered, the application and library files are relinked in order to resolve references.
One advantage of the present invention is that the reordering is done such that the pages referenced when an application file or library file is loaded are sequentially placed within the executable file. A sequential load access pattern is beneficial, as it takes full advantage of read-ahead performed by the file system. When a page is referenced and brought into memory, most file systems automatically bring one or more additional pages into memory. If the additional pages are not needed, they are not used by the loader. However, the present invention allows pages of an executable file to be stored in the order in which they will most likely be loaded. Thus, when the file system performs read-ahead, and brings additional pages into memory, these additional pages are the next pages needed and are loaded. By taking advantage of the file system""s read-ahead process, application and library load times can be reduced, because I/O wait time associated with the request of pages is overlapped with the processing (i.e. loading) of previously requested pages.
Another advantage of the present invention is that library pages which are not used are less likely to even be accessed from storage. By storing the pages of a library file in the order in which the library file is loaded, pages that are referenced are stored before those pages which are not referenced. Thus, pages which are not referenced are not likely to ever be brought into memory by the file system""s read-ahead process.